/**
 * 文件管理模块
 * 负责文件系统的操作，包括目录创建、文件读写等
 */
class FileManager {
    constructor() {
        this.dataDir = 'data';
        this.previewsDir = 'previews';
        this.templatesDir = 'data/templates';
        this.pagesDir = 'data/pages';
        this.usersDir = 'data/users';
    }

    /**
     * 获取基础目录路径
     * @returns {string} 基础目录路径
     */
    getBaseDir() {
        if (typeof __dirname !== 'undefined') {
            // 在Node.js环境中，__dirname指向public/js/modules/，需要回到项目根目录
            return require('path').join(__dirname, '../../../');
        }
        return process.cwd();
    }

    /**
     * 确保必要的目录存在
     * @returns {Promise<void>}
     */
    async ensureDirectories() {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            const baseDir = this.getBaseDir();
            await fs.ensureDir(path.join(baseDir, this.dataDir));
            await fs.ensureDir(path.join(baseDir, this.previewsDir));
            await fs.ensureDir(path.join(baseDir, this.templatesDir));
            await fs.ensureDir(path.join(baseDir, this.pagesDir));
            await fs.ensureDir(path.join(baseDir, this.usersDir));
        } catch (error) {
            console.error('创建目录失败:', error);
            throw error;
        }
    }

    /**
     * 保存页面数据到文件
     * @param {Object} pageData - 页面数据
     * @param {string} filename - 文件名
     * @returns {Promise<Object>} 保存结果
     */
    async savePageData(pageData, filename) {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            // 验证文件名
            if (!this.isValidFilename(filename)) {
                throw new Error('文件名包含非法字符');
            }

            const baseDir = this.getBaseDir();
            const filePath = path.join(baseDir, this.templatesDir, `${filename}.json`);
            
            // 添加时间戳和元数据
            const dataWithMetadata = {
                ...pageData,
                metadata: {
                    createdAt: new Date().toISOString(),
                    updatedAt: new Date().toISOString(),
                    version: '1.0.0'
                }
            };

            await fs.writeJson(filePath, dataWithMetadata, { spaces: 2 });
            
            return {
                success: true,
                message: '保存成功',
                filePath: filePath
            };
        } catch (error) {
            console.error('保存页面数据失败:', error);
            return {
                success: false,
                message: '保存失败',
                error: error.message
            };
        }
    }

    /**
     * 从文件加载页面数据
     * @param {string} filename - 文件名
     * @returns {Promise<Object>} 页面数据
     */
    async loadPageData(filename) {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            // 验证文件名
            if (!this.isValidFilename(filename)) {
                throw new Error('文件名包含非法字符');
            }

            const baseDir = this.getBaseDir();
            const filePath = path.join(baseDir, this.templatesDir, `${filename}.json`);
            const pageData = await fs.readJson(filePath);
            
            return {
                success: true,
                data: pageData
            };
        } catch (error) {
            console.error('加载页面数据失败:', error);
            return {
                success: false,
                message: '文件不存在或读取失败',
                error: error.message
            };
        }
    }

    /**
     * 获取所有页面文件列表
     * @returns {Promise<Array>} 页面文件列表
     */
    async getPageList() {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            const baseDir = this.getBaseDir();
            const dataDir = path.join(baseDir, this.templatesDir);
            const files = await fs.readdir(dataDir);
            
            const pages = files
                .filter(file => file.endsWith('.json'))
                .map(file => {
                    const filename = file.replace('.json', '');
                    return {
                        filename: filename,
                        name: filename,
                        extension: '.json'
                    };
                })
                .sort((a, b) => a.name.localeCompare(b.name));

            return {
                success: true,
                data: pages
            };
        } catch (error) {
            console.error('获取页面列表失败:', error);
            return {
                success: true,
                data: []
            };
        }
    }

    /**
     * 保存预览HTML文件
     * @param {string} html - HTML内容
     * @param {string} filename - 文件名
     * @returns {Promise<Object>} 保存结果
     */
    async savePreviewHTML(html, filename) {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            // 验证文件名
            if (!this.isValidFilename(filename)) {
                throw new Error('文件名包含非法字符');
            }

            const baseDir = this.getBaseDir();
            const filePath = path.join(baseDir, this.previewsDir, `${filename}.html`);
            await fs.writeFile(filePath, html, 'utf8');
            
            return {
                success: true,
                message: '预览生成成功',
                filePath: filePath,
                url: `/previews/${filename}.html`
            };
        } catch (error) {
            console.error('保存预览HTML失败:', error);
            return {
                success: false,
                message: '预览生成失败',
                error: error.message
            };
        }
    }

    /**
     * 删除页面文件
     * @param {string} filename - 文件名
     * @returns {Promise<Object>} 删除结果
     */
    async deletePage(filename) {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            // 验证文件名
            if (!this.isValidFilename(filename)) {
                throw new Error('文件名包含非法字符');
            }

            const baseDir = this.getBaseDir();
            const filePath = path.join(baseDir, this.templatesDir, `${filename}.json`);
            await fs.remove(filePath);
            
            return {
                success: true,
                message: '删除成功'
            };
        } catch (error) {
            console.error('删除页面失败:', error);
            return {
                success: false,
                message: '删除失败',
                error: error.message
            };
        }
    }

    /**
     * 检查文件是否存在
     * @param {string} filename - 文件名
     * @returns {Promise<boolean>} 文件是否存在
     */
    async fileExists(filename) {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            const baseDir = this.getBaseDir();
            const filePath = path.join(baseDir, this.templatesDir, `${filename}.json`);
            return await fs.pathExists(filePath);
        } catch (error) {
            return false;
        }
    }

    /**
     * 获取文件信息
     * @param {string} filename - 文件名
     * @returns {Promise<Object>} 文件信息
     */
    async getFileInfo(filename) {
        const fs = require('fs-extra');
        const path = require('path');

        try {
            const baseDir = this.getBaseDir();
            const filePath = path.join(baseDir, this.templatesDir, `${filename}.json`);
            const stats = await fs.stat(filePath);
            
            return {
                success: true,
                data: {
                    filename: filename,
                    size: stats.size,
                    createdAt: stats.birthtime,
                    updatedAt: stats.mtime,
                    isFile: stats.isFile()
                }
            };
        } catch (error) {
            return {
                success: false,
                message: '获取文件信息失败',
                error: error.message
            };
        }
    }

    /**
     * 验证文件名是否合法
     * @param {string} filename - 文件名
     * @returns {boolean} 是否合法
     */
    isValidFilename(filename) {
        if (!filename || typeof filename !== 'string') {
            return false;
        }

        // 检查文件名长度
        if (filename.length < 1 || filename.length > 100) {
            return false;
        }

        // 检查是否包含非法字符
        const invalidChars = /[<>:"/\\|?*\x00-\x1f]/;
        if (invalidChars.test(filename)) {
            return false;
        }

        // 检查是否以点开头或结尾
        if (filename.startsWith('.') || filename.endsWith('.')) {
            return false;
        }

        return true;
    }

    /**
     * 清理临时文件
     * @param {number} maxAge - 最大年龄（毫秒）
     * @returns {Promise<Object>} 清理结果
     */
    async cleanupTempFiles(maxAge = 24 * 60 * 60 * 1000) { // 默认24小时
        const fs = require('fs-extra');
        const path = require('path');

        try {
            const baseDir = this.getBaseDir();
            const previewsDir = path.join(baseDir, this.previewsDir);
            const files = await fs.readdir(previewsDir);
            const now = Date.now();
            let cleanedCount = 0;

            for (const file of files) {
                if (file.endsWith('.html')) {
                    const filePath = path.join(previewsDir, file);
                    const stats = await fs.stat(filePath);
                    const age = now - stats.mtime.getTime();

                    if (age > maxAge) {
                        await fs.remove(filePath);
                        cleanedCount++;
                    }
                }
            }

            return {
                success: true,
                message: `清理了 ${cleanedCount} 个临时文件`
            };
        } catch (error) {
            console.error('清理临时文件失败:', error);
            return {
                success: false,
                message: '清理失败',
                error: error.message
            };
        }
    }
}

// 导出类（如果使用模块系统）
if (typeof module !== 'undefined' && module.exports) {
    module.exports = FileManager;
}
